C++ 43-46 继承的概念和意义
43 继承的概念和意义
思考：类之间是否存在直接的关联关系？
生活中的例子
组合关系：整体与部分的关系
实例分析：组合关系的描述
#include <iostream>
#include <string>
using namespace std;
class Memory {
public:
Memory() {
cout << "Memory()" << endl;
}
~Memory() {
cout << "~Memory()" << endl;
}
};
class Disk {
public:
Disk() {
cout << "Disk()" << endl;
}
~Disk() {
cout << "~Disk()" << endl;
}
};
class CPU {
public:
CPU() {
cout << "CPU()" << endl;
}
~CPU() {
cout << "~CPU()" << endl;
}
};
class MainBoard {
public:
MainBoard() {
cout << "MainBoard()" << endl;
}
~MainBoard() {
cout << "~MainBoard()" << endl;
}
};
class Computer {
Memory mMem;
Disk mDisk;
CPU mCPU;
MainBoard mMainBoard;
public:
Computer() {
cout << "Computer()" << endl;
}
void power() {
cout << "power()" << endl;
}
void reset() {
cout << "reset()" << endl;
}
~Computer() {
cout << "~Computer()" << endl;
}
};
int main() {
Computer c;
return 0;
}
类之间的组合关系
组合关系的特点：将其它类的对象作为当前类的成员使用；当前类的对象与成员对象的生命期相同；成员对象在用法上与普通对象完全一致。
生活中的例子
继承关系：父子关系
惊艳的继承
面向对象中的继承指类之间的父子关系：子类拥有父类的所有属性和行为；子类就是一种特殊的父类；子类对象可以当作父类对象使用；子类中可以添加父类没有的方法和属性。
C++中通过下面的方式描述继承关系
class Parent {
public:
void method() { };
private:
int mv;
}
class Child : public Parent { //描述继承关系
};
编程实验：继承初体验
#include <iostream>
#include <string>
using namespace std;
class Parent {
int mv;
public:
Parent() {
cout << "Parent()" << endl;
mv = 100;
}
void method() {
cout << "mv = " << mv << endl;
}
};
class Child : public Parent {
public:
void hello() {
cout << "I'm Child calss!" << endl;
}
};
int main() {
Child c;
c.hello();
c.method();
return 0;
}
重要原则：子类就是一个特殊的父类；子类对象可以直接初始化父类对象；子类对象可以直接赋值给父类对象。
继承的意义
继承是C++中代码复用的重要手段。通过继承，可以获得父类的所有功能，并且可以在子类中重写已有功能，或者添加新功能
编程实验
- 继承的强化练习
#include <iostream>
#include <string>
using namespace std;
class Memory
{
public:
Memory()
{
cout << "Memory()" << endl;
}
~Memory()
{
cout << "~Memory()" << endl;
}
};
class Disk
{
public:
Disk()
{
cout << "Disk()" << endl;
}
~Disk()
{
cout << "~Disk()" << endl;
}
};
class CPU
{
public:
CPU()
{
cout << "CPU()" << endl;
}
~CPU()
{
cout << "~CPU()" << endl;
}
};
class MainBoard
{
public:
MainBoard()
{
cout << "MainBoard()" << endl;
}
~MainBoard()
{
cout << "~MainBoard()" << endl;
}
};
class Computer
{
Memory mMem;
Disk mDisk;
CPU mCPU;
MainBoard mMainBoard;
public:
Computer()
{
cout << "Computer()" << endl;
}
void power()
{
cout << "power()" << endl;
}
void reset()
{
cout << "reset()" << endl;
}
~Computer()
{
cout << "~Computer()" << endl;
}
};
class HPBook : public Computer
{
string mOS;
public:
HPBook()
{
mOS = "Windows 8";
}
void install(string os)
{
mOS = os;
}
void OS()
{
cout << mOS << endl;
}
};
class MacBook : public Computer
{
public:
void OS()
{
cout << "Mac OS" << endl;
}
};
int main()
{
HPBook hp;
hp.power();
hp.install("Ubuntu 16.04 LTS");
hp.OS();
cout << endl;
MacBook mac;
mac.OS();
return 0;
}
小结
- 继承是面向对象中类之间的一种关系
- 子类拥有父类的所有属性和行为
- 子类对象可以当作父类对象使用
- 子类可以添加父类没有的方法和属性
- 继承是面向对象中代码复用的重要手段
44 继承中的访问级别
值得思考的问题
子类是否可以直接访问父类的私有成员？
思考过程
-
根据面向对象理论
子类拥有父类的一切属性和行为->子类能够直接访问父类的私有成员
-
根据C++语法
外界不能直接访问类的private成员->子类不能直接访问父类的私有成员
编程实验
- 继承中的访问级别
#include <iostream>
#include <string>
using namespace std;
class Parent
{
private:
int mv;
public:
Parent()
{
mv = 100;
}
int value()
{
return mv;
}
};
class Child : public Parent
{
public:
int addValue(int v)
{
mv = mv + v; // ???? 如何访问父类的非公有成员
}
};
int main()
{
return 0;
}
继承中的访问级别
- 面向对象中的访问级别不只是public 和 private
- 可以定义protected访问级别
- 关键字protected的意义
- 修饰的成员不能被外界直接访问
- 修饰的成员可以被子类直接访问
编程实验
- protected初体验
#include <iostream>
#include <string>
using namespace std;
class Parent
{
protected:
int mv;
public:
Parent()
{
mv = 100;
}
int value()
{
return mv;
}
};
class Child : public Parent
{
public:
int addValue(int v)
{
mv = mv + v;
}
};
int main()
{
Parent p;
cout << "p.mv = " << p.value() << endl;
// p.mv = 1000; // error
Child c;
cout << "c.mv = " << c.value() << endl;
c.addValue(50);
cout << "c.mv = " << c.value() << endl;
// c.mv = 10000; // error
return 0;
}
思考：为什么面向对象中需要protected？
定义类时访问级别的选择
组合与继承的综合实例
编程实验
- 综合实例
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
class Object
{
protected:
string mName;
string mInfo;
public:
Object()
{
mName = "Object";
mInfo = "";
}
string name()
{
return mName;
}
string info()
{
return mInfo;
}
};
class Point : public Object
{
private:
int mX;
int mY;
public:
Point(int x = 0, int y = 0)
{
ostringstream s;
mX = x;
mY = y;
mName = "Point";
s << "P(" << mX << ", " << mY << ")";
mInfo = s.str();
}
int x()
{
return mX;
}
int y()
{
return mY;
}
};
class Line : public Object
{
private:
Point mP1;
Point mP2;
public:
Line(Point p1, Point p2)
{
ostringstream s;
mP1 = p1;
mP2 = p2;
mName = "Line";
s << "Line from " << mP1.info() << " to " << mP2.info();
mInfo = s.str();
}
Point begin()
{
return mP1;
}
Point end()
{
return mP2;
}
};
int main()
{
Object o;
Point p(1, 2);
Point pn(5, 6);
Line l(p, pn);
cout << o.name() << endl;
cout << o.info() << endl;
cout << endl;
cout << p.name() << endl;
cout << p.info() << endl;
cout << endl;
cout << l.name() << endl;
cout << l.info() << endl;
return 0;
}
小结
- 面向对象中的访问级别不只是public和private
- protected修饰的成员不能被外界所访问
- protected使得子类能够访问父类的成员
- protected关键字是为了继承专门设计的
- 没有protected就无法完成真正意义上的代码复用
45 不同的继承方式
被忽视的细节
冒号（:）表示继承关系，Parent表示被继承的类，public的意义是什么？
class Parent
{
};
class Child : public Parent
{
};
有趣的问题
是否可以将继承语句中的public换成protected或者private？如果可以，与public继承有什么区别？
编程实验
- 有趣的尝试
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
class Object
{
protected:
string mName;
string mInfo;
public:
Object()
{
mName = "Object";
mInfo = "";
}
string name()
{
return mName;
}
string info()
{
return mInfo;
}
};
class Point : public Object
{
private:
int mX;
int mY;
public:
Point(int x = 0, int y = 0)
{
ostringstream s;
mX = x;
mY = y;
mName = "Point";
s << "P(" << mX << ", " << mY << ")";
mInfo = s.str();
}
int x()
{
return mX;
}
int y()
{
return mY;
}
};
class Line : public Object
{
private:
Point mP1;
Point mP2;
public:
Line(Point p1, Point p2)
{
ostringstream s;
mP1 = p1;
mP2 = p2;
mName = "Line";
s << "Line from " << mP1.info() << " to " << mP2.info();
mInfo = s.str();
}
Point begin()
{
return mP1;
}
Point end()
{
return mP2;
}
};
int main()
{
Object o;
Point p(1, 2);
Point pn(5, 6);
Line l(p, pn);
cout << o.name() << endl;
cout << o.info() << endl;
cout << endl;
cout << p.name() << endl;
cout << p.info() << endl;
cout << endl;
cout << l.name() << endl;
cout << l.info() << endl;
return 0;
}
不同的继承方式
- C++中支持三种不同的继承方式
- public继承
- 父类成员在子类中保持原有访问级别
- private继承
- 父类成员在子类成员中变为私有成员
- protected继承
- 父类中的公有成员变为保护成员，其它成员保持不变
- public继承
继承成员的访问属性 = Max{继承 方式，父类成员访问属性}
C++中的默认继承方式为private！
编程实验
- 继承与访问级别深度实践
#include <iostream>
#include <string>
using namespace std;
class Parent
{
protected:
int m_a;
protected:
int m_b;
public:
int m_c;
void set(int a, int b, int c)
{
m_a = a;
m_b = b;
m_c = c;
}
};
class Child_A : public Parent
{
public:
void print()
{
cout << "m_a" << m_a << endl;
cout << "m_b" << m_b << endl;
cout << "m_c" << m_c << endl;
}
};
class Child_B : protected Parent
{
public:
void print()
{
cout << "m_a" << m_a << endl;
cout << "m_b" << m_b << endl;
cout << "m_c" << m_c << endl;
}
};
class Child_C : private Parent
{
public:
void print()
{
cout << "m_a" << m_a << endl;
cout << "m_b" << m_b << endl;
cout << "m_c" << m_c << endl;
}
};
int main()
{
Child_A a;
Child_B b;
Child_C c;
a.m_c = 100;
// b.m_c = 100; // Child_B 保护继承自 Parent， 所以所有的 public 成员全部变成了 protected 成员， 因此外界无法访问
// c.m_c = 100; // Child_C 私有继承自 Parent， 所以所有的成员全部变成了 private 成员， 因此外界无法访问
a.set(1, 1, 1);
// b.set(2, 2, 2);
// c.set(3, 3, 3);
a.print();
b.print();
c.print();
return 0;
}
遗憾的事实
- 一般而言，C++工程项目中只使用public继承
- C++的派生语言只支持一种继承方式（public继承）
- protected和private 继承带来的复杂性远大于实用性
编程实验
- C++派生语言初探
//D语言
module D_Demo;
import std.stdio;
import std.string;
class Obj
{
protected:
string mName;
string mInfo;
public:
this()
{
mName = "Object";
mInfo = "";
}
string name()
{
return mName;
}
string info()
{
return mInfo;
}
}
class Point : Obj
{
private:
int mX;
int mY;
public:
this(int x, int y)
{
mX = x;
mY = y;
mName = "Point";
mInfo = format("P(%d, %d)", mX, mY);
}
int x()
{
return mX;
}
int y()
{
return mY;
}
}
void main(string[] args)
{
writefln("D Demo"); // D Demo
Point p = new Point(1, 2);
writefln(p.name()); // Point
writefln(p.info()); // P(1, 2)
}
//C#
class Obj
{
protected string mName;
protected string mInfo;
public Obj()
{
mName = "Object";
mInfo = "";
}
public string name()
{
return mName;
}
public string info()
{
return mInfo;
}
}
class Point : Obj
{
private int mX;
private int mY;
public Point(int x, int y)
{
mX = x;
mY = y;
mName = "Point";
mInfo = "P(" + mX + ", " + mY + ")";
}
public int x()
{
return mX;
}
public int y()
{
return mY;
}
}
class Program
{
public static void Main(string[] args)
{
System.Console.WriteLine("C# Demo"); // C# Demo
Point p = new Point(1, 2);
System.Console.WriteLine(p.name()); // Point
System.Console.WriteLine(p.info()); // P(1, 2)
}
}
//Java
class Obj
{
protected String mName;
protected String mInfo;
public Obj()
{
mName = "Object";
mInfo = "";
}
public String name()
{
return mName;
}
public String info()
{
return mInfo;
}
}
class Point extends Obj
{
private int mX;
private int mY;
public Point(int x, int y)
{
mX = x;
mY = y;
mName = "Point";
mInfo = "P(" + mX + ", " + mY + ")";
}
public int x()
{
return mX;
}
public int y()
{
return mY;
}
}
class Program {
public static void main(String[] args){
System.out.println("Java Demo"); // Java Demo
Point p = new Point(1, 2);
System.out.println(p.name()); // Point
System.out.println(p.info()); // P(1, 2)
}
}
小结
- C++中支持3种不同的继承方式
- 继承方式直接影响父类成员在子类中的访问属性
- 一般而言，工程中只使用public的继承方式
- C++的派生语言中支持public继承方式
46 继承中的构造与析构
思考
如何初始化父类成员？父类构造函数和子类构造函数有什么关系？
子类对象的构造
- 子类中可以定义构造函数
- 子类构造函数
- 必须对继承而来的成员进行初 始化
- 直接通过初始化列表或者赋值的方式进行初始
- 调用父类构造函数进行初始化
- 必须对继承而来的成员进行初 始化
- 父类构造函数在子类中的调用方式
- 默认调用
- 适用于无参构造函数和使用默认参数的构造函数
- 显示调用
- 通过初始化列表进行调用
- 适用于所有父类构造函数
- 默认调用
- 父类构造函数的使用
class Child :public Parent
{
public:
Child() /*隐式调用*/
{
cout<<"Child"<<endl;
}
Child(string s) /*显示调用*/
: Parent("Parameter to Parent")
{
cout<<"Child():"<<s<<endl;
}
};
编程实验
- 子类的构造函数
#include <iostream>
#include <string>
using namespace std;
class Parent
{
public:
Parent()
{
cout << "Parent()" << endl;
}
Parent(string s)
{
cout << "Parent(string s) : " << s << endl;
}
};
class Child : public Parent
{
public:
Child()
{
cout << "Child()" << endl;
}
Child(string s) : Parent(s)
{
cout << "Child(string s) : " << s << endl;
}
};
int main()
{
Child c;
Child cc("cc");
return 0;
}
-
构造规则
- 子类对象在创建时会首先调用父类的构造函数
- 先执行父类构造函数再执行子类的构造函数
- 父类构造函数可以被隐式调用或者显示调用
-
对象创建时构造函数的调用顺序
- 调用父类的构造函数
- 调用成员变量的构造函数
- 调用类自身的构造函数
口诀心法：先父母，后客人，再自己。
编程实验
- 子类构造深度解析
#include <iostream>
#include <string>
using namespace std;
class Parent
{
public:
Parent()
{
cout << "Parent()" << endl;
}
Parent(string s)
{
cout << "Parent(string s) : " << s << endl;
}
};
class Child : public Parent
{
public:
Child()
{
cout << "Child()" << endl;
}
Child(string s) : Parent(s)
{
cout << "Child(string s) : " << s << endl;
}
};
int main()
{
Child c;
Child cc("cc");
return 0;
}
子类对象的析构
- 析构函数的调用顺序与构造函数相反
- 执行自身的析构函数
- 执行成员变量的析构函数
- 执行父类的析构函数
编程实验
- 对象的析构
#include <iostream>
#include <string>
using namespace std;
class Object
{
string ms;
public:
Object(string s)
{
cout << "Object(string s) : " << s << endl;
ms = s;
}
~Object()
{
cout << "~Object() : " << ms << endl;
}
};
class Parent : public Object
{
string ms;
public:
Parent() : Object("Default")
{
cout << "Parent()" << endl;
ms = "Default";
}
Parent(string s) : Object(s)
{
cout << "Parent(string s) : " << s << endl;
ms = s;
}
~Parent()
{
cout << "~Parent() : " << ms << endl;
}
};
class Child : public Parent
{
Object mO1;
Object mO2;
string ms;
public:
Child() : mO1("Default 1"), mO2("Default 2")
{
cout << "Child()" << endl;
ms = "Default";
}
Child(string s) : Parent(s), mO1(s + " 1"), mO2(s + " 2")
{
cout << "Child(string s) : " << s << endl;
ms = s;
}
~Child()
{
cout << "~Child() " << ms << endl;
}
};
int main()
{
Child cc("cc");
cout << endl;
return 0;
}
小结
- 子类对象在创建时需要调用父类构造函数进行初始化
- 先执行父类构造函数然后执行成员的构造函数
- 父类构造函数显示调用需要在初始化列表中进行
- 子类对象在销毁时需要调用父类析构函数进行清理
- 析构顺序与构造顺序对称相反